Python 网络通信-udp、tcp 与 socket

前言：

1. UDP 和 TCP 及 socket 介绍；
2. 网络七层协议(四/五层模型)；
3. IP 地址与端口；
4. Python3 编码转换；
5. Socket 套接字；
6. UDP 协议；
7. TCP 协议。

Python 网络通信

一、UDP 和 TCP 及 socket 介绍

注意：udp 和 tcp 都是网络传输的协议，只不过具体传输形式不一样，但功能都是定义网络传输数据规则。

udp 和 tcp (发短信和打电话)(不同: 是否创建链接)

1. udp 是用户数据报协议，UDP(User Datagram Protocol)不能保证数据的准确性和有效性。
   (数据报:是通过网络传输的数据的基本单元)

2. tcp 是传输控制协议，TCP(Transmission Control Protocol)能保证数据的准确性和有效性。
   (和udp差不多依靠socket技术)

3. socket 就是具体实现 tcp 和 udp 的底层技术(也称套接字/流对象)(不在网络七层协议之列-因为是技术不是协议)

二、网络七层协议(四/五层模型)

三、IP 地址与端口

网络通信过程中，之所需要ip、port等，就是为了能够将一个复杂的通信过程进行任务划分，从而保证数据准确无误的传递。

ip 地址

作用：用来在网络中标记一台电脑，比如 192．168．1．1 在本地局域网上是唯一的。

注意：IP 地址 127．0．0．1~127．255．255．255 用于回路测试

端口

端口是通过端口号来标记的，端口号只有整数，范围是从0到65535

知名端口

众所周知的端口号，范围从0到1023

80 端口分配给HTTP服务
21 端口分配给FTP服务

动态端口

范围是从1024到65535

查看端口

netstat －an 查看端口状态
lsof -i:port 查看端口占用

四、Python3 编码转换

str->bytes:encode编码

bytes->str:decode解码

# encoding: 在解码编码过程中使用的编码(此处指“编码方案”是名词)
# errors: 错误的处理方案
bytes.decode(encoding="utf-8", errors="strict")
str.encode(encoding="utf-8", errors="strict")

详细的可以参照官方文档：

str.encode()

bytes.decode()

五、Socket 套接字

socket(简称 套接字也成为插口–流对象) 是进程间通信的一种方式，它与其他进程间通信的一个主要不同是：

它能实现不同主机间的进程间通信，我们网络上各种各样的服务大多都是基于 Socket 来完成通信的。

例如我们每天浏览网页、QQ 聊天、收发 email 等等。

Socket 反问理解

———start———

what 是什么？（概念、理解）

socket(简称 套接字 也称为插口–流对象) 是进程间通信的一种方式

why 为什么用？（用它的好处，特点/不同点）

是实现tcp和udp的底层技术，能实现 不同主机间 的进程间通信

where 在哪使用？（案例、项目）

网络程序发送、接收数据（发短信、打电话、广播）

————end————

六、UDP 协议

udp 是用户数据报协议，UDP (User Datagram Protocol) 不能保证数据的准确性和有效性。 (数据报:是通过网络传输的数据的基本单元)

udp 通信模型中，在通信开始之前，不需要建立相关的链接，只需要发送数据即可，类似于生活中，”写信/发短信”

python 使用 udp 协议要通过 socket 技术:

使用步骤：1.引包 2.创建流对象(ipv4, udp) 3.发送(二进制字符串, 元组ip和端口) 4.关闭流对象

创建 socket 语法

# Address Family：可以选择 AF_INET（用于 Internet 进程间通信） 或者 AF_UNIX（用于同一台机器进程间通信）,实际工作中常用AF_INET
# Type：套接字类型，可以是 SOCK_STREAM（流式套接字，主要用于 TCP 协议）或者 SOCK_DGRAM（数据报套接字，主要用于 UDP 协议）

import socket
    socket.socket(AddressFamily, Type)

案例

1.udp 发送

# 1.引包
import socket

if __name__ == '__main__':
    # 2.创建流对象(ipv4, udp)
    # socket是一个模块
    # socket.socket是一个类
    #   socket.AF_INET: 这个socket数据传世用ipv4;
    #   socket.SOCK_DGRAM: 这个socket使用udp协议进行数据传输;
    
    # socket对象(套接字);    插口 -- 流对象(就要关闭 -- 发送和接收信息)
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    
    # 3.发送(二进制字符串, 元组ip和端口)
    str1 = '你好,我是udp协议发送的测试数据...'
    tuple1 = ('192.168.1.1', 8888)
    udp_socket.sendto(str1.encode('utf-8'), tuple1)
    print(tuple1, '发送成功!')
    
    # 4.关闭流对象
    udp_socket.close()

2.udp 接收（主动接收方需手动绑定端口，发送方才知道发送给谁）

import socket

if __name__ == '__main__':
    # 1.创建套接字对象
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    # 2. 绑定本地的相关信息，如果一个网络程序不绑定，则系统会随机分配
    local_addr = ('', 8888) #  ip地址和端口号，ip一般不用写，表示本机的任何一个ip
    udp_socket.bind(local_addr)

    # 3.数据接收( recvfrom() )
    #       参数: 最多一次性接收1024字节;
    #       返回值: 一个元组(二进制数据, ip及port组成的元组)
    #       recvfrom(): 可以阻塞代码!( 类似input() )
    #       发送和接收数据的时候,udp承受的最大上线为: 64k
    str2, tuple2 = udp_socket.recvfrom(1024)
    print(str2)
    print(tuple2)
    print(str2.decode('utf-8'))
    # print(str2.decode('gbk'))

    # 4.关闭套接字
    udp_socket.close()

3.udp 聊天器

"""
说明：在一个电脑中编写1个程序，有2个功能：
    1.获取键盘数据，并将其发送给对方
    2.接收数据并显示
    并且功能数据进行选择以上的2个功能调用
"""

import socket


def send_msg(udp_socket):
    """获取键盘数据，并将其发送给对方"""
    # 1. 从键盘输入数据
    msg = input("\n请输入要发送的数据:")
    # 2. 输入对方的ip地址
    dest_ip = input("\n请输入对方的ip地址:")
    # 3. 输入对方的port
    dest_port = int(input("\n请输入对方的port:"))
    # 4. 发送数据
    udp_socket.sendto(msg.encode("utf-8"), (dest_ip, dest_port))


def recv_msg(udp_socket):
    """接收数据并显示"""
    # 1. 接收数据
    recv_msg = udp_socket.recvfrom(1024)
    # 2. 解码
    recv_ip = recv_msg[1]
    recv_msg = recv_msg[0].decode("utf-8")
    # 3. 显示接收到的数据
    print(">>>%s:%s" % (str(recv_ip), recv_msg))


def main():
    # 1. 创建套接字
    udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    # 2. 绑定本地信息
    udp_socket.bind(("", 7890))
    while True:
        # 3. 选择功能
        print("="*30)
        print("1:发送消息")
        print("2:接收消息")
        print("="*30)
        op_num = input("请输入要操作的功能序号:")

        # 4. 根据选择调用相应的函数
        if op_num == "1":
            send_msg(udp_socket)
        elif op_num == "2":
            recv_msg(udp_socket)
        else:
            print("输入有误，请重新输入...")

if __name__ == "__main__":
    main()

七、TCP 协议

TCP协议，传输控制协议（英语：Transmission Control Protocol，缩写为 TCP）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由 IETF 的 RFC 793 定义。

TCP通信需要经过 创建连接、数据传送、终止连接 三个步骤。

TCP通信模型中，在通信开始之前，一定要先建立相关的链接，才能发送数据，类似于生活中，”打电话””

TCP 特点

1.面向连接

1. 通信双方必须先建立连接才能进行数据的传输，双方都必须为该连接分配必要的系统内核资源，以管理连接的状态和连接上的传输。
2. TCP不适用于广播的应用程序，基于广播的应用程序请使用UDP协议。

2.可靠传输

1. TCP采用发送应答机制
   • TCP发送的每个报文段都必须得到接收方的应答才认为这个TCP报文段传输成功
2. 超时重传
   • 发送端发出一个报文段之后就启动定时器，如果在定时时间内没有收到应答就重新发送这个报文段。
   • TCP为了保证不发生丢包，就给每个包一个序号，同时序号也保证了传送到接收端实体的包的按序接收。然后接收端实体对已成功收到的包发回一个相应的确认（ACK）；如果发送端实体在合理的往返时延（RTT）内未收到确认，那么对应的数据包就被假设为已丢失将会被进行重传。
3. 错误校验
   • TCP用一个校验和函数来检验数据是否有错误；在发送和接收时都要计算校验和。
4. 流量控制和阻塞管理
   • 流量控制用来避免主机发送得过快而使接收方来不及完全收下。

tcp 注意点

1. tcp服务器一般情况下都需要绑定ip和端口，否则客户端找不到这个服务器及其服务对应的端口
2. tcp客户端一般不绑定，因为是主动链接服务器，所以只要确定好服务器的ip、port等信息就好，本地客户端可以随机
3. tcp服务器中通过listen可以将socket创建出来的主动套接字变为被动的，这是做tcp服务器时必须要做的
4. 当客户端需要链接服务器时，就需要使用connect进行链接，udp是不需要链接的而是直接发送，但是tcp必须先链接，只有链接成功才能通信
5. 当一个tcp客户端连接服务器时，服务器端会有1个新的套接字，这个套接字用来标记这个客户端，单独为这个客户端服务
6. listen后的套接字是被动套接字，用来接收新的客户端的链接请求的，而accept返回的新套接字是标记这个新客户端的
7. 关闭listen后的套接字意味着被动套接字关闭了，会导致新的客户端不能够链接服务器，但是之前已经链接成功的客户端正常通信。
8. 关闭accept返回的套接字意味着这个客户端已经服务完毕
9. 当客户端的套接字调用close后，服务器端会recv解堵塞，并且返回的长度为0，因此服务器可以通过返回数据的长度来区别客户端是否已经下线
10. 空字符串能够直接发送不能够直接接收(tcp服务端会过滤)

tcp 三次握手和四次挥手

tcp 三次握手图解

标志位	序号
SYN: 表示连接请求	seq:表示报文序号
ACK: 表示确认	ack: 表示确认号
FIN: 表示关闭连接

（1）第一次握手：Client将标志位SYN置为1，随机产生一个值seq=J，并将该数据包发送给Server，Client进入SYN_SENT状态，等待Server确认。
（2）第二次握手：Server收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1， ack (number )=J+1，随机产生一个值seq=K，并将该数据包发送给Client以确认连接请求，Server进入SYN_RCVD状态。
（3）第三次握手：Client收到确认后，检查ack是否为J+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=K+1，并将该数据包发送给Server，Server检查ack是否为K+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client与Server之间可以开始传输数据了。

理解总结：
1.客户端发起连接请求，等待服务端确定
2.服务端确认连接请求
3.客户端收到确认后，再次发送数据包验证（验证正确，连接成功，完成三次握手）

tcp 四次挥手图解

客户端主动关闭（三次挥手）：
（1）第一次挥手：客户端发送一个FIN，用来关闭客户端到服务的数据传送。
（2）第二次挥手：服务端发送一个ACK，用来关闭服务端到客户端的数据传送。
（3) 第三次挥手：客户端收到ACK后，接着发送一个ACK给服务端，确认序号为收到序号+1。

服务端主动关闭（四次挥手）：
（1）第一次挥手：server发送一个FIN，用来关闭server到client的数据传送。
（2) 第二次挥手：client收到FIN后，发送一个ACK给server，确认序号为收到序号+1。
（3）第三次挥手：client发送一个FIN，用来关闭Client到Server的数据传送。
（4) 第四次挥手：Server收到FIN后，接着发送一个ACK给Client，确认序号为收到序号+1。

理解总结：
1.服务端 close()（我要关闭连接了）
2.客户端收到后发送一条消息（别急，事情还没处理完...）
3.客户端处理完成后 close()（可以关闭连接了）
4.服务端接着发送一个 ACK 给 Client（连接已关闭！四次挥手完成）

案例

1.tcp 客户端

from socket import *

# 创建socket
tcp_client_socket = socket(AF_INET, SOCK_STREAM)

# 目的信息
server_ip = input("请输入服务器ip:")
server_port = int(input("请输入服务器port:"))

# 链接服务器
tcp_client_socket.connect((server_ip, server_port))

# 提示用户输入数据
send_data = input("请输入要发送的数据：")

tcp_client_socket.send(send_data.encode("gbk"))

# 接收对方发送过来的数据，最大接收1024个字节
recvData = tcp_client_socket.recv(1024)
print('接收到的数据为:', recvData.decode('gbk'))

# 关闭套接字
tcp_client_socket.close()

2.tcp 服务端

"""
步骤：
    1.socket创建一个套接字
    2.bind绑定ip和port
    3.listen使套接字变为可以被动链接
    4.accept等待客户端的链接
    5.recv/send接收发送数据
"""

from socket import *

# 创建socket
tcp_server_socket = socket(AF_INET, SOCK_STREAM)

# 本地信息
address = ('', 7788)

# 绑定
tcp_server_socket.bind(address)

# 使用socket创建的套接字默认的属性是主动的，使用listen将其变为被动的，这样就可以接收别人的链接了
tcp_server_socket.listen(128)

# 如果有新的客户端来链接服务器，那么就产生一个新的套接字专门为这个客户端服务
# client_socket用来为这个客户端服务
# tcp_server_socket就可以省下来专门等待其他新客户端的链接
client_socket, clientAddr = tcp_server_socket.accept()

# 接收对方发送过来的数据
recv_data = client_socket.recv(1024)  # 接收1024个字节
print('接收到的数据为:', recv_data.decode('gbk'))

# 发送一些数据到客户端
client_socket.send("thank you !".encode('gbk'))

# 关闭为这个客户端服务的套接字，只要关闭了，就意味着为不能再为这个客户端服务了，如果还需要服务，只能再次重新连接
client_socket.close()

八、TCP 与 UDP 的不同点

TCP：

• 面向连接（确认有创建三方交握，连接已创建才作传输。）
• 有序数据传输
• 重发丢失的数据包
• 舍弃重复的数据包
• 无差错的数据传输
• 阻塞/流量控制

UDP 通信模型（类似于写信/发短信/广播/视频聊天）

TCP 通信模型（类似于打电话）